package com.liwei.thread.ReentrantLock;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockSample {

    public static void main(String[] args) {
        //        testSynchronized();
        testReentrantLock();
    }

    public static void testReentrantLock() {
        final SampleSupport1 support = new SampleSupport1();
        Thread first = new Thread(new Runnable() {
            public void run() {
                try {
                    support.doSomething();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread second = new Thread(new Runnable() {
            public void run() {
                try {
                    support.doSomething();
                } catch (InterruptedException e) {
                    System.out
                        .println("Second Thread Interrupted without executing counter++,beacuse it waits a long time.");
                }
            }
        });

        executeTest(first, second);
    }

    public static void testSynchronized() {
        final SampleSupport2 support2 = new SampleSupport2();

        Runnable runnable = new Runnable() {
            public void run() {
                support2.doSomething();
            }
        };

        Thread third = new Thread(runnable);
        Thread fourth = new Thread(runnable);

        executeTest(third, fourth);
    }

    /**
     * Make thread a run faster than thread b, then thread b will be interruted
     * after about 1s.
     * 
     * @param a
     * @param b
     */
    public static void executeTest(Thread a, Thread b) {
        a.start();
        try {
            Thread.sleep(100);
            b.start(); // The main thread sleep 100ms, and then start the second
            // thread.

            Thread.sleep(1000);
            // 1s later, the main thread decided not to allow the second thread
            // wait any longer.
            b.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
